#! /bin/env python
# -*- coding: utf-8 -*-

"""
Script to turn image into css
"""

import Image
import sys

__author__ = "Reverland (lhtlyy@gmail.com)"


def getcss(im):
    """docstring for get"""
    css = """position: absolute;
    top: 30px;
    left: 30px;
    width: 0;
    height: 0;
    box-shadow:
        """
    string = '%dpx %dpx 0px 1px rgb%s,\n'
    for y in range(0, im.size[1], 1):
        for x in range(0, im.size[0], 1):
            if im.size[1] - y <= 1 and im.size[0] - x <= 1:
                string = '%dpx %dpx 0px 1px rgb%s;\n'
            color = im.getpixel((x, y))
            css += string % (x, y, color)
    return css


def gethtml(css):
    """docstring for gethtml"""
    html = """
    <div style="
    %s"></div>
    """ % css
    return html

if __name__ == '__main__':
    filename = sys.argv[1]
    #outfile = sys.argv[2]
    im = Image.open(filename)
    ratio = 0.5
    size = (int(ratio * im.size[0]), int(ratio * im.size[1]))
    im.thumbnail(size)
    html = gethtml(getcss(im))
    print html
    # with open(outfile, 'wb') as f:
    #     f.write(html)

import matplotlib.pyplot as plt
import numpy as np
tolerance = 1e-1
radius = np.pi
v_o = 20
x_o, y_o = 0, radius

x_m, y_m = -radius, 0
v_m = 5

plt.figure(figsize=(10, 10), dpi=80)
plt.title(" missile flight simulator ", fontsize=40)
plt.xlim(-4, 4)
plt.ylim(-4, 4)
#plt.xticks([])
#plt.yticks([])

# set spines
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data', 0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data', 0))
plt.xticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi], [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
plt.yticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi], [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])

# Note object and missile
plt.annotate('object start point', xy=(x_o, y_o),  xycoords='data',
             xytext=(+15, +15), textcoords='offset points', fontsize=12,
             arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
plt.annotate('missile start point', xy=(x_m, y_m),  xycoords='data',
             xytext=(+15, +15), textcoords='offset points', fontsize=12,
             arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

# alpha labels
for label in ax.get_xticklabels() + ax.get_yticklabels():
    label.set_fontsize(16)
    label.set_bbox(dict(facecolor='white', edgecolor='None', alpha=0.65))


while True:
    if x_o == 0 and y_o == radius:
        beta = 0
    elif x_o == 0 and y_o == radius:
        beta = np.pi
    elif x_o < 0:
        beta = np.pi / 2 * 3 - np.arctan(y_o / x_o)
    else:
        beta = np.pi / 2 - np.arctan(y_o / x_o)
    if np.sqrt((x_o - x_m) ** 2 + (y_o - y_m) ** 2) < tolerance:
        print "collision"
        plt.plot(x_m, y_m, 'o')
        plt.annotate('crash point', xy=(x_m, y_m),  xycoords='data',
                     xytext=(+15, +15), textcoords='offset points', fontsize=12,
                     arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
        plt.pause(0.1)
        break
    elif x_o < x_m:
        alpha = np.pi + np.arctan((y_o - y_m) / (x_o - x_m))
    elif x_o == x_m:
        alpha = np.pi / 2
    else:
        alpha = np.arctan((y_o - y_m) / (x_o - x_m))
    x_o = radius * np.sin(beta + v_o * 0.01 / np.pi / 2)
    y_o = radius * np.cos(beta + v_o * 0.01 / np.pi / 2)
    x_m = x_m + v_m * 0.01 * np.cos(alpha)
    y_m = y_m + v_m * 0.01 * np.sin(alpha)
    #print alpha, beta
    plt.plot(x_o, y_o, 'r.', alpha=.5)
    plt.plot(x_m, y_m, 'bx', alpha=.5)
    plt.legend(("target", "missile"), loc="upper left", prop={'size': 12})
    plt.pause(0.1)

import matplotlib.pyplot as plt
import numpy as np
tolerance = 1e-1
radius = np.pi

# missile 1
x_m1, y_m1 = -np.pi, 0
v_m1 = 5

# missile 2
x_m2, y_m2 = 0, np.pi
v_m2 = v_m1
# missile 3
x_m3, y_m3 = np.pi, 0
v_m3 = v_m1
# missile 4
x_m4, y_m4 = 0, -np.pi
v_m4 = v_m1

plt.figure(figsize=(10, 10), dpi=80)
plt.title(" missile flight simulator ", fontsize=40)
plt.xlim(-4, 4)
plt.ylim(-4, 4)
#plt.xticks([])
#plt.yticks([])

# set spines
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data', 0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data', 0))
plt.xticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi], [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
plt.yticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi], [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])

plt.annotate('missile start point', xy=(x_m1, y_m1),  xycoords='data',
             xytext=(+15, +15), textcoords='offset points', fontsize=12,
             arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

# alpha labels
for label in ax.get_xticklabels() + ax.get_yticklabels():
    label.set_fontsize(16)
    label.set_bbox(dict(facecolor='white', edgecolor='None', alpha=0.65))


class ob(object):
    """docstring for ob"""
    def __init__(self, x, y):
        self.x = x
        self.y = y


class missile(ob):
    """docstring for missile"""
    def __init__(self, x, y):
        super(missile, self).__init__(x, y)

    def forward(self, v, target):
        """docstring for forward"""
        if self.x < target.x:
            alpha = np.arctan((target.y - self.y) / (target.x - self.x))
        elif self.x > target.x:
            alpha = np.pi + np.arctan((target.y - self.y) / (target.x - self.x))
        elif self.x == target.x and self.y < target.y:
            alpha = np.pi / 2
        else:
            alpha = -np.pi / 2
        self.x = self.x + v * 0.01 * np.cos(alpha)
        self.y = self.y + v * 0.01 * np.sin(alpha)
        return self.x, self.y

    def distance(self, target):
        """docstring for distance"""
        return np.sqrt((self.x - target.x) ** 2 + (self.y - target.y) ** 2)


class target(ob):
    """docstring for target"""
    def __init__(self, x, y):
        super(target, self).__init__(x, y)

    def newposition(self, x, y):
        """docstring for newposition"""
        self.x = x
        self.y = y

m1 = missile(x_m1, y_m1)
m2 = missile(x_m2, y_m2)
m3 = missile(x_m3, y_m3)
m4 = missile(x_m4, y_m4)

while True:
    if m1.distance(m2) < tolerance or m1.distance(m3) < tolerance or m1.distance(m4) < tolerance:
        print "collision"
        plt.plot(x_m1, y_m1, 'o')
        plt.annotate('crash point', xy=(x_m1, y_m1),  xycoords='data',
                     xytext=(+15, +15), textcoords='offset points', fontsize=12,
                     arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
        plt.pause(0.1)
        plt.show()
        break
    elif m3.distance(m2) < tolerance or m3.distance(m4) < tolerance:
        print "collision"
        plt.plot(x_m3, y_m3, 'o')
        plt.annotate('crash point', xy=(x_m3, y_m3),  xycoords='data',
                     xytext=(+15, +15), textcoords='offset points', fontsize=12,
                     arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
        plt.pause(0.1)
        plt.show
        break
    x_m1, y_m1 = m1.forward(v_m1, m2)
    x_m2, y_m2 = m2.forward(v_m2, m3)
    x_m3, y_m3 = m3.forward(v_m3, m4)
    x_m4, y_m4 = m4.forward(v_m4, m1)
    #print alpha, beta
    plt.plot(x_m1, y_m1, 'bx', alpha=.5)
    plt.plot(x_m2, y_m2, 'k*', alpha=.5)
    plt.plot(x_m3, y_m3, 'r.', alpha=.5)
    plt.plot(x_m4, y_m4, 'gp', alpha=.5)
    plt.legend(("missile1", "missile2", "missile3", "missile4"), loc="upper left", prop={'size': 12})
    plt.pause(0.1)

#! /bin/env python
# -*- coding: utf-8 -*-

"""
Turn images into acsii.
"""

__author__ = 'Reverland (lhtlyy@gmail.com)'

import Image
import ImageOps
import sys


filename = 'a.jpg'


def makeHTMLbox(body, fontsize, imagesize):
    """takes one long string of words and a width(px) then put them in an HTML box"""
    boxStr = """<div style=\"font-size: %spx;line-height: 100%s; width: %s;background-color: rgb(0, 0, 0);border: 1px grey solid;text-align: center; overflow: hidden;\">%s</div>
    """
    return boxStr % (fontsize, '%', imagesize[0], body)


def makeHTMLascii(body, color):
    """take words and , and create an HTML word """
    #num = str(random.randint(0,255))
    # return random color for every tags
    color = 'rgb(%s, %s, %s)' % color
    # get the html data
    wordStr = '<span style=\"color:%s;float:left;\">%s</span>'
    return wordStr % (color, body)


def i2m(im, fontsize):
    """turn an image into ascii like matrix"""
    im = im.convert('L')
    im = ImageOps.autocontrast(im)
    im.thumbnail((im.size[0] / fontsize, im.size[1] / fontsize))
    string = ''
    colors = [(0, i, 0) for i in range(0, 256, 17)]
    words = '据说只有到了十五字才会有经验的'
    for y in range(im.size[1]):
        for x in range(im.size[0]):
            p = im.getpixel((x, y))
            i = 14
            while i >= 0:
                if p >= i * 17:
                    s = makeHTMLascii(words[3 * i:3 * (i + 1)], colors[i])
                    break
                i -= 1
            if x % im.size[0] == 0 and y > 0:
                s = s + '<br/>'
            string = string + s
    return string


def i2a(im, fontsize):
    """turn an image into ascii with colors"""
    im = im.convert('RGB')
    im = ImageOps.autocontrast(im)
    im.thumbnail((im.size[0] / fontsize, im.size[1] / fontsize))
    string = ''
    for y in range(im.size[1]):
        for x in range(im.size[0]):
            c = im.getpixel((x, y))
            # print c
            s = makeHTMLascii('翻', c)
            if x % im.size[0] == 0 and y > 0:
                s = s + '<br/>'
            string = string + s
    return string


def getHTMLascii(filename, fontsize, style='matrix', outputfile='a.html', scale=1):
    """Got html ascii image"""
    im = Image.open(filename)
    size = (int(im.size[0] * scale), int(im.size[1] * scale))
    im.thumbnail(size, Image.ANTIALIAS)
    if style == 'matrix':
        ascii = makeHTMLbox(i2m(im, fontsize), fontsize, im.size)
    elif style == 'ascii':
        ascii = i2a(im, fontsize)
    else:
        print "Just support ascii and matrix now, fall back to matrix"
        ascii = makeHTMLbox(i2m(im, fontsize), fontsize, im.size)
    with open(outputfile, 'wb') as f:
        f.write(ascii)
    return 1


if __name__ == '__main__':
    if sys.argv[1] == '--help' or sys.argv[1] == '-h':
        print """Usage:python i2a.py filename fontsize [optional-parameter]
        optional-parameter:
            scale -- between (0, 1)
            style -- matrix or ascii"""
    else:
        filename = sys.argv[1]
        try:
            fontsize = int(sys.argv[2])
        except:
            fontsize = int(raw_input('input fontsize please:'))
        try:
            scale = float(sys.argv[3])
        except:
            scale = 1
        try:
            style = sys.argv[4]
        except:
            style = 'matrix'
        getHTMLascii(filename, fontsize, scale=scale)